package com.Algorithm.HUAWEI.three20220323;

import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: zjz
 * @Date: 2022/03/24/11:07
 * @Description:
 * @Target:
 */
public class 输出单向链表中倒数第k个结点 {
    /*
        描述
        输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。

        链表结点定义如下：
        struct LinkedNode
        {
            int m_nKey;
            LinkedNode* m_pNext;
        };

        正常返回倒数第k个结点指针，异常返回空指针.
        要求：
        (1)正序构建链表;
        (2)构建后要忘记链表长度。
        数据范围：链表长度满足 1≤n≤1000  ， ，链表中数据满足 0≤val≤10000

        本题有多组样例输入。

        输入描述：
        输入说明
        1 输入链表结点个数
        2 输入链表的值
        3 输入k的值
        输出描述：
        输出一个整数
        示例1
        输入：
        8
        1 2 3 4 5 6 7 8
        4
        输出：
        5
*/

    // 先确保能输入进来

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()){
            Integer integer = Integer.valueOf(in.nextLine());
            String[] s = in.nextLine().split(" ");
            Integer integer1 = Integer.valueOf(in.nextLine());
            process1(integer,s,integer1);
        }


    }




    static void process1(Integer integer ,String[] s, Integer integer1){
        LinkedNode headNode = new LinkedNode();
        headNode.m_nKey = Integer.valueOf(s[0]);
        LinkedNode tempNode = new LinkedNode();
        tempNode = headNode;
        for (int i = 1; i < integer; i++) {
            LinkedNode newNode = new LinkedNode();
            newNode.m_nKey = Integer.valueOf(s[i]);
            tempNode.m_pNext = newNode;
            tempNode = newNode;
        }

        tempNode = headNode;
        for (int i = 0; i < integer1; i++) {
            tempNode = tempNode.m_pNext;
        }

        while (tempNode!=null){
//            System.out.print(headNode.m_nKey+" ");
            headNode = headNode.m_pNext;
            tempNode = tempNode.m_pNext;
        }
//        System.out.println();

        if (headNode!=null){
            System.out.println(headNode.m_nKey);
        }else {
            System.out.println("0");
        }

    }


    static void process(Integer integer ,String[] s, Integer integer1){
        LinkedNode headerNode = new LinkedNode();
        headerNode.m_nKey = Integer.valueOf(s[s.length-1]);
        for (int i = 0; i < integer-1; i++) {
            LinkedNode linkedNode = new LinkedNode(Integer.valueOf(s[i]),headerNode.m_pNext);
            headerNode.m_pNext = linkedNode;
        }

        boolean flag = false;
/*
        while (headerNode!=null){
            System.out.print(headerNode.m_nKey+" ");
            headerNode = headerNode.m_pNext;
        }
*/


        for (int i = 1; i <= integer1; i++) {
            if (i==integer1){
                flag = true;
                System.out.println(headerNode.m_nKey);
            }
            headerNode = headerNode.m_pNext;
        }

        if (flag == false){
            System.out.println("0");
        }
    }

    // 定义链表结构
    static class  LinkedNode{
        int m_nKey;
        LinkedNode m_pNext;

        public LinkedNode() {
        }

        public LinkedNode(int m_nKey, LinkedNode m_pNext) {
            this.m_nKey = m_nKey;
            this.m_pNext = m_pNext;
        }
    }
}
